/*
 * Copyright (C) 2010-2011 sunjumper@163.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package mfinder.impl;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import mfinder.ActionFactory;
import mfinder.ActionInvocation;
import mfinder.ActionProxy;
import mfinder.MFinderException;
import mfinder.ObjectFactory;
import mfinder.annotation.Action;
import mfinder.annotation.Interceptor;
import mfinder.annotation.InterceptorStack;
import mfinder.annotation.Namespace;
import mfinder.annotation.Parameter;
import mfinder.annotation.Result;
import mfinder.annotation.ResultType;
import mfinder.util.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 默认ActionFactory的实现类，以‘/’作为路径的分隔符。
 * <p>
 * DefaultActionFactory中的加载和调用的拦截器、结果类型对象均为单例；
 * {@link Action}对象根据其{@link Action#scope()}属性判断是否单例。
 * </p>
 * <p>
 * DefaultActionFactory中的Action、拦截器、拦截栈及结果类型的集合在初始化时加载完成，
 * 之后任何情况下DefaultActionFactory不再执行集合的修改和删除操作。对返回集合进行的修改和删除请自行保证其线程安全性。
 * </p>
 */
public class DefaultActionFactory implements ActionFactory {

    /** 日志 */
    private static final Logger LOG = LoggerFactory.getLogger(DefaultActionFactory.class);

    /** 路径分隔符 */
    public static final char PATH_SEPARATOR = '/';

    /** 全匹配标识 */
    private String match = PathTree.SINGLE_MATCH;

    /** 路径后缀，默认为'.'；非空时截断路径后缀 */
    private String extension = ".";

    /**
     * Action运行时上下文的类型，用于传递上下文参数时的界限判断。
     * 未指定参数类型即null时表示允许ActionInvocation类型的任意子类。
     */
    private Class<? extends ActionInvocation> actionInvocationClass;

    /**
     * 默认拦截栈名称。
     * 默认拦截栈名称的设置仅在初始化Action时，更改默认拦截栈名称仅影响以后加载的Action。
     *
     * @see #createActionProxy(Method, Object)
     */
    private String defaultInterceptorStack = null;

    /**
     * 默认视图类型。
     * 默认视图类型的更改影响每次调用。
     *
     * @see #invokeAction(String, Object[])
     */
    private String defaultResultType = null;

    /**
     * {@link #actionCache}最大缓存数目，默认最大缓存50w条记录；缓存数目小于0则无缓存。
     */
    private int actionCacheNumber = 500000;

    /**
     * 创建对象的工厂对象。
     */
    private ObjectFactory objectFactory = new ObjectFactory() {

        @Override
        public <T> T newInstance(Class<T> clazz) {
            try {
                return clazz.newInstance();
            } catch (IllegalAccessException e) {
                throw new MFinderException(e, null);
            } catch (InstantiationException e) {
                throw new MFinderException(e, null);
            }
        }
    };
////////////////////////////////////////////////////////////////////////////////

    /** 拦截器 */
    private final Map<String, InterceptorProxy> interceptors = new HashMap<String, InterceptorProxy>();

    /** 拦截栈 */
    private final Map<String, InterceptorStackProxy> interceptorStacks = new HashMap<String, InterceptorStackProxy>();

    /** 实际的Action树结构路径映射 */
    private final PathTreeMap<DefaultActionProxy> actions = new PathTreeMap<DefaultActionProxy>(PATH_SEPARATOR);

    /** Action路径与代理对象的映射缓存 */
    private final Map<String, ActionCacheEntry> actionCache = new java.util.concurrent.ConcurrentHashMap<String, ActionCacheEntry>(10000);

    /** 结果类型 */
    private final Map<String, ResultTypeProxy> resultTypes = new HashMap<String, ResultTypeProxy>();

    /** 默认的全局结果对象集合 */
    private final Map<String, ResultProxy> results = new HashMap<String, ResultProxy>();

    /**
     * 通过路径调用相应的Action，可以传递Action代理方法相应的参数。
     * Action调用是否为线程安全取决于路径所映射方法的线程安全性。
     *
     * @param path Action的映射路径。
     * @param params Action的调用参数。
     *
     * @return 调用后的结果；如果结果为字符串类型非空且存在结果对象，则查找相应的结果类型并返回调用后的结果；
     * 反之直接返回结果。
     *
     * @throws MFinderException 如果发生调用错误。
     *
     * @see #invokeUndefinedResult
     * @see #invokeObjectResult
     */
    @Override
    public Object invokeAction(String path, Object... params) throws MFinderException {
        LOG.debug("Start invoking Action [{}]; Parameters {} ", path, java.util.Arrays.toString(params));
        //remove the extension
        if (StringUtil.isNotNull(extension)) {
            int len = extension.length();
            //extension为特定的标记字符，则截去标记字符后的部分
            if (len == 1 && !Character.isLetterOrDigit(extension.charAt(0))) {
                int index = path.lastIndexOf(extension.charAt(0));
                if (index != -1) {
                    path = path.substring(0, index);
                }
            } else {
                //extension为特定的后缀字符串
                if (path.endsWith(extension)) {
                    //extension前一位非字母或数字
                    if (!Character.isLetterOrDigit(path.charAt(path.length() - len - 1))) {
                        len++;
                    }
                    path = path.substring(0, path.length() - len);
                }
            }
        }

        //create ActionInvocation
        ActionInvocation invocation = createActionInvocation(path, params);

        //invoke
        Object res = null;
        try {
            res = invocation.invoke(params);
            LOG.debug("Get invoked Action [{}] result : [{}]", path, res);
            //result is string
            if (res instanceof String) {
                String resInfo = res.toString();
                ActionProxy ap = invocation.getActionProxy();
                Result result = null;

                //如果action中存在相应的结果映射
                if ((result = ap.getResults().get(resInfo)) != null) {
                    //调用结果对象相应的结果类型
                    Object rr = invokeByResult(invocation, result);
                    if (rr != null)
                        res = rr;
                } //如果Action调用结果的路径信息中包含':'可省略Action中的@Result(name = "*"...)
                else if ((result = ap.getResults().get(match)) != null || resInfo.indexOf(':') != -1) {
                    //非完全匹配字符串路径的调用
                    Object rr = invokeByString(invocation, result, resInfo);
                    if (rr != null)
                        res = rr;
                } //如果全局结果对象集合中存在相应的结果映射
                else if (results.containsKey(resInfo)) {
                    ResultProxy rp = results.get(resInfo);
                    //ResultProxy直接调用
                    Object rr = rp.invoke(rp.isRequireAction() ? invocation : null);
                    if (rr != null)
                        res = rr;

                    result = rp.getResult();
                    //当Result的type值不为空时，执行相应的ResultType
                    if (StringUtil.isNotNull(result.type())) {
                        rr = invokeByResult(invocation, result);
                        if (rr != null)
                            res = rr;
                    }
                } else {
                    //若无匹配
                    Object rr = invokeUndefinedResult(invocation, resInfo);
                    if (rr != null)
                        res = rr;
                }
            } else {
                //非字符串结果的对象处理方式
                Object rr = invokeObjectResult(invocation, res);
                if (rr != null)
                    res = rr;
            }
        } catch (InvocationProxyException e) {
            //去除不必要的InvocationProxyException异常，封装异常的源并抛出。
            throw new InvocationProxyException(e.getSource(), null);
        }
        LOG.debug("Finish invoking Action [{}]; Parameters {}; Final result : [{}]", new Object[]{
                    path, java.util.Arrays.toString(params), String.valueOf(res)
                });
        return res;
    }

    /**
     * 创建Action调用时的上下文对象。
     *
     * @param path Action的映射路径。
     * @param params Action的调用参数。
     *
     * @return Action调用时的上下文对象。
     */
    protected ActionInvocation createActionInvocation(String path, Object... params) {
        //cache
        ActionCacheEntry ace = null;
        if (actionCacheNumber > 0)
            ace = actionCache.get(path);

        //Action代理对象
        DefaultActionProxy ap = null;
        //路径的参数匹配映射
        Map<String, String> matchParameters = null;

        //get from cache
        if (ace != null) {
            ap = ace.actionProxy;
            matchParameters = ace.matchParameters;
        } else {
            //initiate matchParameters
            matchParameters = new HashMap<String, String>(2);
            ap = actions.get(path, matchParameters);

            if (ap == null)
                throw new MFinderException("No such Action : " + path, null);

            //put in cache
            ace = new ActionCacheEntry(ap, matchParameters);
            putActionCache(path, ace);
        }

        //scope action
        ap = ap.getInstance();
        //未完成 actionInvocationClass ???
        //create DefaultActionInvocation
        DefaultActionInvocation ai = new DefaultActionInvocation(this, ap, params);
        //setActionPathParameters
        ai.setActionPathParameters(matchParameters);
        return ai;
    }

    /**
     * 调用Result相应的ResultType。
     *
     * @param invocation Action运行时上下文。
     * @param result 结果对象。
     *
     * @return 调用ResultType后的结果。
     */
    private Object invokeByResult(ActionInvocation invocation, Result result) {
        String type = result.type();
        //default result type
        if (StringUtil.isNull(type))
            type = defaultResultType;

        ResultTypeProxy rtp = resultTypes.get(type);
        if (rtp == null)
            throw new MFinderException("No such ResultType [" + type + "] at : "
                    + invocation.getActionProxy().getMethod(), invocation.getActionProxy());

        if (rtp.isRequireAction()) {
            ((DefaultActionInvocation) invocation).setResult(result);
        }
        LOG.debug("Invoke ResultType [{}] at : {}", type, rtp.getMethod());
        //结果类型调用
        return rtp.invoke(rtp.isRequireAction() ? invocation : null);
    }

    /**
     * 提供非完全匹配路径的结果对象的调用方式。
     * 默认提供全字符串结果的匹配处理。
     *
     * @param invocation Action运行时上下文。
     * @param result Action调用完成后的结果对象。
     * @param pathinfo Action调用的结果对象的路径信息。
     *
     * @return 调用相应结果类型后的值，无匹配则返回 null。
     *
     * @see #invokeByResult
     */
    private Object invokeByString(ActionInvocation invocation, Result result, String pathinfo) {
        //default values
        String type = defaultResultType;
        String loc = null;
        if (result != null) {
            if (StringUtil.isNotNull(result.type()))
                type = result.type();
            loc = result.location();
        }
        //parse the string "type:location"
        String[] parseRes = parseMatch(pathinfo, type, loc);
        type = parseRes[0];
        loc = parseRes[1];
        //重新封装result参数
        Result res = new DefaultActionInvocation.ResultProxy(match, type, loc);
        return invokeByResult(invocation, res);
    }

    /**
     * "type:location"形式的字符串解析。
     *
     * @param pathinfo "type:location"形式的字符串。
     * @param def type和location的默认值。
     *
     * @return 解析后的{type,location}字符串数组。
     */
    private static String[] parseMatch(String pathinfo, String... def) {
        String type = def[0];
        String loc = def[1];
        //首個非空格非分隔符的位置
        int begin = -1;
        //分隔符前的最后一个非空格字符的位置
        int p1 = -1;
        //分隔符的位置
        int colon = -1;
        int len = pathinfo.length();
        //定位分隔符位置
        for (int i = 0; i < len; i++) {
            char c = pathinfo.charAt(i);
            //may extend
            if (c == ':') {
                colon = i;
                break;
            } else {
                if (c != ' ') {
                    p1 = i;
                    if (begin == -1)
                        begin = i;
                }
            }
        }
        //判断结果类型
        switch (colon) {
            case -1:
                begin = 0;
                p1 = len - 1;
                while (begin < p1 && pathinfo.charAt(begin) == ' ')
                    begin++;
                while (begin < p1 && pathinfo.charAt(p1) == ' ')
                    p1--;
                //非空
                if (begin < p1)
                    type = pathinfo.substring(begin, p1 + 1);
                break;
            case 0:
                break;
            default:
                //非空
                if (begin != -1)
                    type = pathinfo.substring(begin, p1 + 1);
        }
        //分隔符非末位，判断结果路径
        if (colon != -1 && colon != len - 1) {
            //分隔符后的第一个非空格字符的位置
            int p2 = colon + 1;
            //最后一个非空字符的位置
            int end = len - 1;
            while (p2 < end && pathinfo.charAt(p2) == ' ')
                p2++;
            while (p2 < end && pathinfo.charAt(end) == ' ')
                end--;

            if (p2 != end)
                loc = pathinfo.substring(p2, end + 1);
        }
        //返回0.type 1.location形式的数组
        return new String[]{type, loc};
    }

    /**
     * 用于子类继承，提供非字符串<code>string</code>对象的处理方式。
     * 默认直接返回非字符串对象，void方法返回 null 。
     *
     * @param invocation Action运行时上下文。
     * @param res Action调用完成后的结果。
     *
     * @return 非字符串对象。
     */
    protected Object invokeObjectResult(ActionInvocation invocation, Object res) {
        LOG.warn("Return object result [{}] directly at : {}", res, invocation.getActionProxy().getMethod());
        return res;
    }

    /**
     * 用于子类继承，提供Action和全局结果对象集合均未匹配<code>string</code>结果对象情况下的处理方式。
     * 默认直接返回结果字符串。
     *
     * @param invocation Action运行时上下文。
     * @param resInfo Action调用完成后的结果字符串。
     *
     * @return 结果字符串。
     */
    protected Object invokeUndefinedResult(ActionInvocation invocation, String resInfo) {
        LOG.warn("No match Result [{}] at {}, return string directly", resInfo, invocation.getActionProxy().getMethod());
        //throw new MFinderException("No match Result [" + resInfo + "] at " + ap.getMethod(), ap);
        //不作处理直接跳过，直接返回调用结果字符串
        return resInfo;
    }

    /**
     * 添加Action的路径及代理对象至缓存。
     *
     * @param path Action的路径。
     * @param ace Action的缓存对象。
     */
    private void putActionCache(String path, ActionCacheEntry ace) {
        if (actionCacheNumber > 0) {
            //如果缓存数据大于设置的条数，则清空缓存
            if (actionCache.size() > actionCacheNumber)
                actionCache.clear();
            actionCache.put(path, ace);
        }
    }

    /**
     * 清除Action的路径映射缓存。
     */
    public void clearActionCache() {
        actionCache.clear();
    }

    @Override
    public void clear() {
        LOG.info("Clearing MFinder ActionFactory : " + this);
        actionCache.clear();
        actions.clear();
        interceptorStacks.clear();
        interceptors.clear();
        resultTypes.clear();
        Injector.clear();
    }
////////////////////////////////////////////////////////////////////////////////

    /**
     * 添加拦截器。
     *
     * @param ip 拦截器代理对象。
     */
    public void addInterceptor(InterceptorProxy ip) {
        String name = ip.getName();

        if (StringUtil.isNull(name))
            throw new IllegalArgumentException("Null name in Interceptor : " + ip.getMethod());

        if (interceptors.containsKey(name)) {
            LOG.warn("Duplicate Interceptor [" + name + "] : "
                    + interceptors.get(name).getMethod() + " to "
                    + ip.getMethod());
        } else {
            LOG.info("Add Interceptor [{}] at : {} ", name, ip.getMethod());
        }
        interceptors.put(name, ip);
    }

    /**
     * 添加拦截器。
     *
     * @param obj 包含{@link Interceptor}注解的类或实例对象。
     *
     * @see mfinder.annotation.Interceptor
     */
    public void addInterceptors(Object obj) {
        boolean isCls = obj instanceof Class;
        Class cls = isCls ? (Class) obj : obj.getClass();
        Object invoker = isCls ? null : obj;
        Method[] ms = cls.getDeclaredMethods();
        for (Method m : ms) {
            int mod = m.getModifiers();
            //带@Interceptor的public/protected方法
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod))
                    && m.isAnnotationPresent(Interceptor.class)) {
                m.setAccessible(true);
                //static method
                if (Modifier.isStatic(mod)) {
                    addInterceptor(createInterceptorProxy(m, null));
                } else {
                    //为类对象且调用者为 null
                    if (isCls && invoker == null) {
                        invoker = objectFactory.newInstance(cls);
                    }
                    //the same object
                    addInterceptor(createInterceptorProxy(m, invoker));
                }
            }
        }
    }

    /**
     * 添加拦截栈。
     *
     * @param isp 拦截栈代理对象。
     */
    public void addInterceptorStack(InterceptorStackProxy isp) {
        String name = isp.getName();
        if (interceptorStacks.containsKey(name)) {
            LOG.error("Duplicate InterceptorStack : " + name);
        } else {
            LOG.info("Add InterceptorStack [{}] : {}", name, isp);
        }
        interceptorStacks.put(name, isp);
    }

    /**
     * 添加拦截栈。
     *
     * @param obj 包含{@link InterceptorStack}注解的类或实例对象。
     *
     * @see mfinder.annotation.InterceptorStack
     */
    public void addInterceptorStacks(Object obj) {
        boolean isCls = obj instanceof Class;
        Class cls = isCls ? (Class) obj : obj.getClass();
        Object invoker = isCls ? null : obj;
        Field[] fs = cls.getDeclaredFields();
        for (Field f : fs) {
            int mod = f.getModifiers();
            //带@InterceptorStack的public属性
            if (Modifier.isPublic(mod) && f.isAnnotationPresent(InterceptorStack.class)) {
                f.setAccessible(true);
                try {
                    //static field
                    if (Modifier.isStatic(mod)) {
                        addInterceptorStack(createInterceptorStackProxy(f, null));
                    } else {
                        //为类对象且调用者为 null
                        if (isCls && invoker == null) {
                            invoker = objectFactory.newInstance(cls);
                        }
                        //the same object
                        addInterceptorStack(createInterceptorStackProxy(f, invoker));
                    }
                } catch (IllegalAccessException e) {
                    throw new MFinderException(e, null);
                }
            }
        }
    }

////////////////////////////////////////////////////////////////////////////////
    /**
     * 添加结果类型。
     *
     * @param rtp 结果类型的代理对象。
     */
    public void addResultType(ResultTypeProxy rtp) {
        String type = rtp.getType();

        if (StringUtil.isNull(type))
            throw new IllegalArgumentException("Null type in ResultType : " + rtp.getMethod());

        if (resultTypes.containsKey(type)) {
            LOG.warn("Duplicate ResultType [" + type + "] : "
                    + resultTypes.get(type).getMethod() + " to "
                    + rtp.getMethod());
        } else {
            LOG.info("Add ResultType [{}] at : {}", type, rtp.getMethod());
        }
        resultTypes.put(type, rtp);
    }

    /**
     * 添加结果类型。
     *
     * @param obj 包含{@link ResultType}注解的类或实例对象。
     *
     * @see mfinder.annotation.ResultType
     */
    public void addResultTypes(Object obj) {
        boolean isCls = obj instanceof Class;
        Class cls = isCls ? (Class) obj : obj.getClass();
        Object invoker = isCls ? null : obj;
        Method[] ms = cls.getDeclaredMethods();
        for (Method m : ms) {
            int mod = m.getModifiers();
            //带@ResultType的public/protected方法
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod))
                    && m.isAnnotationPresent(ResultType.class)) {
                m.setAccessible(true);
                //static method
                if (Modifier.isStatic(mod)) {
                    addResultType(createResultTypeProxy(m, null));
                } else {
                    //为类对象且调用者为 null
                    if (isCls && invoker == null) {
                        invoker = objectFactory.newInstance(cls);
                    }
                    //the same object
                    addResultType(createResultTypeProxy(m, invoker));
                }
            }
        }
    }

    /**
     * 添加结果对象。
     *
     * @param rp 结果对象的代理对象。
     */
    public void addResult(ResultProxy rp) {
        String name = rp.getResult().name();
        if (results.containsKey(name)) {
            LOG.warn("Duplicate Result [" + name + "] : "
                    + results.get(name).getMethod() + " to "
                    + rp.getMethod());
        } else {
            LOG.info("Add Result [{}] : {}", name, rp.getMethod());
        }
        results.put(name, rp);
    }

    /**
     * 添加全局结果对象。
     *
     * @param obj 包含{@link Result}注解的类或实例对象。
     *
     * @see mfinder.annotation.Result
     */
    public void addResults(Object obj) {
        boolean isCls = obj instanceof Class;
        Class cls = isCls ? (Class) obj : obj.getClass();
        Object invoker = isCls ? null : obj;
        Method[] ms = cls.getDeclaredMethods();
        for (Method m : ms) {
            int mod = m.getModifiers();
            //带@Result的public/protected方法
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod))
                    && m.isAnnotationPresent(Result.class)) {
                m.setAccessible(true);
                //static method
                if (Modifier.isStatic(mod)) {
                    addResult(createResultProxy(m, null));
                } else {
                    //为类对象且调用者为 null
                    if (isCls && invoker == null) {
                        invoker = objectFactory.newInstance(cls);
                    }
                    //the same object
                    addResult(createResultProxy(m, invoker));
                }
            }
        }
    }
/////////////////////////////////////////////////////////////////////////////////

    /**
     * 添加Action。
     *
     * @param ap Action代理对象。
     */
    public void addAction(DefaultActionProxy ap) {
        String aPath = ap.getPath();

        if (StringUtil.isNull(aPath))
            throw new IllegalArgumentException("Null path in Action : " + ap.getMethod());

        DefaultActionProxy exist = actions.get(aPath);
        if (exist != null) {
            LOG.warn("Duplicate Action [" + aPath + "] : "
                    + exist.getMethod() + " to "
                    + ap.getMethod());
        } else {
            LOG.info("Add Action [{}] at : {}", aPath, ap.getMethod());
        }
        actions.put(aPath, ap);
    }

    /**
     * 添加Action。
     *
     * @param obj 包含{@link Action}注解的类或实例对象。
     *
     * @see mfinder.annotation.Action
     */
    public void addActions(Object obj) {
        //判断传入参数为类或实例对象
        boolean isCls = obj instanceof Class;
        Class cls = isCls ? (Class) obj : obj.getClass();
        Object invoker = isCls ? null : obj;
        Method[] ms = cls.getDeclaredMethods();
        for (Method m : ms) {
            int mod = m.getModifiers();
            //带@Action的public/protected方法
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod))
                    && m.isAnnotationPresent(Action.class)) {
                m.setAccessible(true);
                try {
                    //static method
                    if (Modifier.isStatic(mod)) {
                        addAction(createActionProxy(m, null));
                    } else {
                        if (isCls && invoker == null) {
                            invoker = objectFactory.newInstance(cls);
                        }
                        //the same object
                        addAction(createActionProxy(m, invoker));
                    }
                } catch (IllegalAccessException e) {
                    throw new MFinderException(e, null);
                } catch (InvocationTargetException e) {
                    throw new MFinderException(e, null);
                }
            }
        }
    }

////////////////////////////////////////////////////////////////////////////////
    /**
     * 创建Interceptor代理对象。
     *
     * @param method 指定的方法。
     * @param obj 方法所在的对象。
     *
     * @return Interceptor代理对象。
     */
    private InterceptorProxy createInterceptorProxy(Method method, Object obj) {
        Interceptor interceptor = method.getAnnotation(Interceptor.class);
        Class[] params = method.getParameterTypes();

        //check interceptor invoke args
        boolean requireAction = false;
        //interceptor代理的方法无参数或参数仅为ActionInvocation或其子类
        if (params.length == 0) {
            requireAction = false;
        } //未指定actionInvocationClass参数类型时允许ActionInvocation任意子类；否则为actionInvocationClass的父类
        else if (isProxyMethod(params)) {
            requireAction = true;
        } else {
            throw new IllegalArgumentException("Illegal arguments in Interceptor : " + method);
        }
        return new InterceptorProxy(interceptor, method, obj, requireAction);
    }

    /**
     * 创建InterceptorStack代理对象
     *
     * @param field 指定的字段。
     * @param obj 字段所在对象。
     *
     * @return InterceptorStack代理对象。
     *
     * @throws IllegalAccessException 如果调用的对象无法访问指定字段。
     */
    private InterceptorStackProxy createInterceptorStackProxy(Field field, Object obj) throws
            IllegalAccessException {
        InterceptorStack interceptorStack = field.getAnnotation(InterceptorStack.class);
        String name = interceptorStack.name().trim();

        //interceptorStack name
        //未指定拦截栈名称则取字符串的值为名称
        if (StringUtil.isNull(name)) {
            name = field.get(obj).toString();
            //空命名异常
            if (StringUtil.isNull(name))
                throw new IllegalArgumentException("Null name InterceptorStack : "
                        + field.getName() + " at " + obj.getClass());
        }
        //interceptors name
        String[] names = interceptorStack.interceptors();

        List<InterceptorProxy> list = null;
        if (names != null) {
            list = new ArrayList<InterceptorProxy>(names.length);
            //add interceptorStack
            //for (int i = names.length - 1; i >= 0; i--) {
            for (int i = 0; i < names.length; i++) {
                InterceptorProxy ip = interceptors.get(names[i]);
                //if null
                if (ip == null) {
                    LOG.warn("No such Interceptor [{}] at : {}", names[i], field);
                } else {
                    list.add(ip);
                }
            }
        }
        return new InterceptorStackProxy(name, field, list);
    }

    /**
     * 创建ResultType代理对象。
     *
     * @param method 指定的方法。
     * @param obj 方法所在的对象。
     *
     * @return ResultType代理对象。
     */
    private ResultTypeProxy createResultTypeProxy(Method method, Object obj) {
        ResultType resultType = method.getAnnotation(ResultType.class);
        Class[] params = method.getParameterTypes();

        boolean requireAction = false;
        //ResultType代理的方法无参数或参数仅为ActionInvocation或其子类
        if (params.length == 0) {
            requireAction = false;
        } else if (isProxyMethod(params)) {
            requireAction = true;
        } else {
            throw new IllegalArgumentException("Illegal arguments in ResultType : " + method);
        }

        return new ResultTypeProxy(resultType, method, obj, requireAction);
    }

    /**
     * 创建Result代理对象。
     *
     * @param method 指定的方法。
     * @param obj 方法所在的对象。
     *
     * @return Result代理对象
     */
    private ResultProxy createResultProxy(Method method, Object obj) {
        Result res = method.getAnnotation(Result.class);
        Class[] params = method.getParameterTypes();

        boolean requireAction = false;
        //ResultType代理的方法无参数或参数仅为ActionInvocation或其子类
        if (params.length == 0) {
            requireAction = false;
        } else if (isProxyMethod(params)) {
            requireAction = true;
        } else {
            throw new IllegalArgumentException("Illegal arguments in Result : " + method);
        }
        return new ResultProxy(res, method, obj, requireAction);
    }

    /**
     * 判断代理方法的参数是否合法；仅允许无参数方法或仅ActionInvocation类型参数的方法。
     * 未指定参数类型时允许ActionInvocation类型的任意子类；否则为{@link #actionInvocationClass}的父类。
     *
     * @param params 代理方法的参数类型。
     *
     * @return 所代理的方法合法返回true，否则为false。
     */
    private boolean isProxyMethod(Class[] params) {
        if (params.length > 1)
            return false;
        return params.length == 0 ? true : actionInvocationClass == null
                ? ActionInvocation.class.isAssignableFrom(params[0])
                : params[0].isAssignableFrom(actionInvocationClass);
    }

    /**
     * 创建Action代理对象。
     *
     * @param method 指定的方法。
     * @param obj 方法所在的对象。
     *
     * @return Action代理对象。
     */
    private DefaultActionProxy createActionProxy(Method method, Object obj) throws
            IllegalAccessException, InvocationTargetException {
        Namespace ns = method.getDeclaringClass().getAnnotation(Namespace.class);
        //trim empay and '/'
        String namespace = ns == null ? PATH_SEPARATOR + "" : PATH_SEPARATOR + StringUtil.trim(ns.name(), PATH_SEPARATOR);

        String path = null;
        //not nullable Action
        Action action = method.getAnnotation(Action.class);
        //Action名称可能为空字符串
        String aname = action.name().trim();
        if ("".equals(aname)) {
            //Action名称为空字符串时取其方法的名称（区分大小写）
            aname = method.getName();
            //if namespace is '/' or not
            path = namespace.length() == 1 ? PATH_SEPARATOR + aname : namespace + PATH_SEPARATOR + aname;
        } else {
            //action's name can't be null by annotation
            String name = StringUtil.trim(aname, PATH_SEPARATOR);
            //if action's name is trim as empty
            if (name.isEmpty()) {
                path = namespace;
            } else if (PATH_SEPARATOR == aname.charAt(0)) {
                path = PATH_SEPARATOR + name;
            } else {
                //if namespace is '/' or not
                path = namespace.length() == 1 ? PATH_SEPARATOR + name : namespace + PATH_SEPARATOR + name;
            }
        }

        //包含特别属性注入的Action需重新生成对象
        if (obj != null && Injector.actionInjection.containsKey(path)) {
            obj = objectFactory.newInstance(obj.getClass());
            Injector.injectAction(path, obj);
        }

        //Action中不记录路径的后缀名称
        DefaultActionProxy ap = new DefaultActionProxy(this, namespace, path, action, method, obj);

        //void method
        if (void.class == method.getReturnType())
            LOG.warn("Mapping [{}] void method at : {}", ap.getPath(), ap.getMethod());

        //interceptorStack
        String stackName = action.interceptorStack().trim();
        //not not nullable action's interceptors
        String[] interceptorNames = action.interceptors();

        List<InterceptorProxy> inters = new ArrayList<InterceptorProxy>(5);
        //action interceptors
        if (interceptorNames.length != 0) {
            ////action interceptorStack
            if (StringUtil.isNotNull(stackName)) {
                addActionInterceptors(inters, stackName, ap);
            }
            //action中申明的interceptors
            for (String name : action.interceptors()) {
                InterceptorProxy ip = interceptors.get(name);
                if (ip == null) {
                    LOG.warn("No such Interceptor [{}] at : {}", name, ap.getMethod());
                } else {
                    inters.add(ip);
                }
            }
        } //action interceptorStack
        else if (StringUtil.isNotNull(stackName)) {
            addActionInterceptors(inters, stackName, ap);
        } else {
            //是否已设置action的拦截器集合
            boolean setInterceptors = false;
            //namespace interceptorStack & interceptors
            if (ns != null) {
                //namespace interceptorStack
                if (StringUtil.isNotNull(stackName = ns.interceptorStack().trim())) {
                    setInterceptors = true;
                    addActionInterceptors(inters, stackName, ap);
                }
                //namespace interceptors
                if (ns.interceptors().length != 0) {
                    setInterceptors = true;
                    for (String name : ns.interceptors()) {
                        InterceptorProxy ip = interceptors.get(name);
                        if (ip == null) {
                            LOG.warn("No such Interceptor [{}] at : {}", name, ap.getMethod());
                        } else {
                            inters.add(ip);
                        }
                    }
                }
            }
            //defaultInterceptorStack
            if (!setInterceptors) {
                if (StringUtil.isNotNull(stackName = defaultInterceptorStack)) {
                    addActionInterceptors(inters, stackName, ap);
                }
            }
        }
        //trim
        ((ArrayList) inters).trimToSize();
        ap.setInterceptors(inters);

        //set action parameters
        Parameter[] ps = action.parameters();
        Map<String, String[]> params = new HashMap<String, String[]>(ps.length);
        for (Parameter p : ps) {
            params.put(p.name(), p.value());
        }
        ap.setActionParameters(params);
        //set results
        Result[] rs = action.results();
        Map<String, Result> res = new HashMap<String, Result>(rs.length);
        for (Result r : rs) {
            res.put(r.name(), r);
        }
        ap.setResults(res);

        return ap;
    }

    /**
     * 由指定拦截栈名称添加拦截器至Action的拦截器集合。
     *
     * @param interceptors Action的拦截器集合。
     * @param stackName 指定的拦截栈名称。
     * @param ap Action代理对象。
     */
    private void addActionInterceptors(List<InterceptorProxy> interceptors, String stackName,
            DefaultActionProxy ap) {
        InterceptorStackProxy isp = interceptorStacks.get(stackName);
        if (isp == null) {
            LOG.warn("No such InterceptorStack [{}] at : {}", stackName, ap.getMethod());
        } else {
            if (isp.getInterceptors() != null)
                interceptors.addAll(isp.getInterceptors());
        }
    }
////////////////////////////////////////////////////////////////////////////////

    @Override
    public Map<String, DefaultActionProxy> getActions() {
        return actions;
    }

    /**
     * 返回缓存的Action路径与其代理对象的映射。
     *
     * @return 缓存的Action路径与其代理对象的映射。
     */
    public Map<String, Object> getActionCache() {
        return (Map) actionCache;
    }

    @Override
    public Map<String, InterceptorProxy> getInterceptors() {
        return interceptors;
    }

    @Override
    public Map<String, InterceptorStackProxy> getInterceptorStacks() {
        return interceptorStacks;
    }

    @Override
    public Map<String, ResultTypeProxy> getResultTypes() {
        return resultTypes;
    }

    @Override
    public String getDefaultInterceptorStack() {
        return defaultInterceptorStack;
    }

    /**
     * 设置默认拦截栈名称。
     * 更改默认拦截栈名称对已存在的拦截栈{@link #interceptorStacks}无影响。
     * 更改默认拦截栈名称对已存在的{@link #actions}无影响。
     *
     * @param defaultInterceptorStack 默认拦截栈名称。
     */
    public void setDefaultInterceptorStack(String defaultInterceptorStack) {
        LOG.info("setDefaultInterceptorStack : " + defaultInterceptorStack);
        this.defaultInterceptorStack = defaultInterceptorStack;
    }

    @Override
    public String getDefaultResultType() {
        return defaultResultType;
    }

    /**
     * 设置默认结果视图类型。
     * 更改默认结果视图类型会影响已存在的{@link #actions}的结果调用。
     * 如果已有的Action调用结束后使用了默认视图类型，则会被影响。
     *
     * @param defaultResultType 默认视图类型。
     */
    public void setDefaultResultType(String defaultResultType) {
        LOG.info("setDefaultResultType : " + defaultResultType);
        this.defaultResultType = defaultResultType;
    }

    /**
     * 返回全局结果对象集合。
     *
     * @return 全局结果对象集合。
     */
    @Override
    public Map<String, ResultProxy> getResults() {
        return results;
    }

    /**
     * 返回路径后缀分隔符。
     *
     * @return 路径后缀分隔符名称。
     */
    public String getExtension() {
        return extension;
    }

    /**
     * 路径后缀名称。
     * 当后缀为单个字符时，按路径最后出现分割符的位置截断路径后缀；
     * 当后缀为未空字符串时，如果路径已后缀结尾，截断后缀。
     * 更改路径后缀名称对已存在的{@link #actions}无影响。
     *
     * @param extension 路径后缀名称。
     *
     * @see #invokeAction(java.lang.String, java.lang.Object[])
     */
    public void setExtension(String extension) {
        if (extension == null)
            return;
        this.extension = extension.trim();
        LOG.info("setExtension : " + this.extension);
    }

    /**
     * Action运行时上下文的类型。
     *
     * @return Action运行时上下文的类型。
     */
    public Class<? extends ActionInvocation> getActionInvocationClass() {
        return actionInvocationClass;
    }

    /**
     * 设置Action运行时上下文的类型。
     *
     * @param actionInvocationClass Action运行时上下文的类型。
     */
    public void setActionInvocationClass(Class<? extends ActionInvocation> actionInvocationClass) {
        this.actionInvocationClass = actionInvocationClass;
        LOG.info("setActionInvocationClass : " + this.actionInvocationClass);
    }

    /**
     * 返回{@link #getActionCache()}的最大缓存数目。
     *
     * @return {@link #getActionCache()}的最大缓存数目。
     */
    public int getActionCacheNumber() {
        return actionCacheNumber;
    }

    /**
     * 设置{@link #getActionCache()}的最大缓存数目。
     *
     * @param actionCacheNumber {@link #getActionCache()}的最大缓存数目。
     */
    public void setActionCacheNumber(int actionCacheNumber) {
        this.actionCacheNumber = actionCacheNumber;
        LOG.info("setActionCacheNumber : " + this.actionCacheNumber);
    }

    /**
     * 设置创建对象的工厂对象。
     *
     * @param objectFactory 创建对象的工厂对象。
     */
    public void setObjectFactory(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
        LOG.info("setObjectFactory : " + this.objectFactory);
    }

    @Override
    public ObjectFactory getObjectFactory() {
        return objectFactory;
    }

    /**
     * 缓存对象。
     */
    private static class ActionCacheEntry {

        /** Action的代理对象 */
        DefaultActionProxy actionProxy;

        /** Action路径的参数匹配映射，如果没有则为 null */
        Map<String, String> matchParameters;

        /**
         * 构造一个无属性的缓存对象。
         */
        ActionCacheEntry() {
        }

        /**
         * 构造一个指定Action的代理对象和Action路径的参数匹配映射的缓存对象。
         *
         * @param actionProxy Action的代理对象。
         * @param matchParameters Action路径的参数匹配映射。
         */
        ActionCacheEntry(DefaultActionProxy actionProxy, Map<String, String> matchParameters) {
            this.actionProxy = actionProxy;
            this.matchParameters = matchParameters;
        }
    }
}
